home *** CD-ROM | disk | FTP | other *** search
/ Dr. Windows 3 / dr win3.zip / dr win3 / PROGRAMR / FLAT.ZIP / FLATDATA.C < prev    next >
C/C++ Source or Header  |  1993-07-09  |  11KB  |  573 lines
  1. #define WIN31
  2. #include <windows.h>
  3. #include <bwcc.h>
  4. #include "flatm.h"
  5. #pragma hdrstop
  6. #include "flatdata.h"
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include "\wmemchec\memcheck.h"
  10.  
  11. /*--------------------------------------------
  12. -
  13. -         FLATDATA.C for Flat Windows Program
  14. -
  15. -   Maintains the data and shows how to extract
  16. -          info from the WIN.INI file                                          
  17. -
  18. -               Dennis R. Fischer
  19. -                 Denam Systems
  20. -          1115 Madison St. NE  Suite 226
  21. -              Salem, Oregon  97303
  22. -
  23. -             CompuServe 70405,1422
  24. -        Internet 70405.1422@compuserve.com
  25. -
  26. -        Developed with Borland 3.1 Compiler
  27. -
  28. -     Free for the taking but please give credit
  29. -                where credit is do
  30. -
  31. ----------------------------------------------*/              
  32.  
  33.  
  34. struct tagFLATDATA fd;
  35. struct tagTOTMONEY TotalMoney;
  36. WORKTYPE           Work;
  37. HINSTANCE          hInst;
  38. DATEFORMATTYPE     DateFormat=NoDateFormat;
  39. char               szDateMark[2] = {"/"};
  40. BOOL               bExtraDayZero = FALSE;
  41. BOOL               bExtraMonthZero = FALSE;
  42. BOOL               bHasCentury = FALSE;
  43.  
  44. DATEFORMATTYPE SetDateFormat(void)
  45. {
  46.     /* Looks at the 'intl' section of WIN.INI and
  47.          sets the date variables */
  48.  
  49.     char szTemp[11];
  50.     char ch, chDateMark;
  51.   LPSTR lpStr;
  52.     DATEFORMATTYPE df1, df2, df3;
  53.     BOOL bQuit;
  54.   int i, count;
  55.  
  56.   /* Grab the short date seperator */
  57.     GetProfileString("intl", "sDate", "/", szDateMark, 2);
  58.   chDateMark = szDateMark[0];
  59.  
  60.     /* Get the type of format */
  61.     DateFormat = MonDayYear;
  62.     df1 = NoDateFormat;
  63.     df2 = NoDateFormat;
  64.   df3 = NoDateFormat;
  65.   GetProfileString("intl", "sShortDate", "", szTemp, 10); 
  66.     AnsiUpper(szTemp);
  67.     bExtraDayZero = FALSE;
  68.     bExtraMonthZero = FALSE;
  69.   bHasCentury = FALSE;
  70.     if (lstrlen(szTemp) > 0) {
  71.         i=0;
  72.         count = 0;
  73.     /* Does the short date (month) have a leading zero */
  74.         do{
  75.             if (szTemp[i] == 'M')
  76.                 count++;
  77.       i++;
  78.         }while(szTemp[i]);
  79.         if (count > 1)
  80.             bExtraMonthZero = TRUE;
  81.     /* Does the short date (day) have a leading zero */
  82.         i=0;
  83.         count=0;
  84.         do{
  85.             if(szTemp[i] == 'D')
  86.                 count++;
  87.             i++;
  88.         }while(szTemp[i]);
  89.         if (count > 1)
  90.             bExtraDayZero = TRUE;
  91.     /* Does short date include the century (01/01/9999) */ 
  92.         i=0;
  93.         count=0;
  94.         do{
  95.             if(szTemp[i] == 'Y')
  96.                 count++;
  97.             i++;
  98.         }while(szTemp[i]);
  99.         if (count > 2)
  100.         bHasCentury = TRUE;
  101.  
  102.     /* now check the date format */
  103.         lpStr = szTemp;
  104.         ch = szTemp[0];
  105.         if (ch == 'M') {
  106.         df1 = MonDayYear;
  107.         }
  108.         else {
  109.             if (ch == 'D')
  110.                 df1 = DayMonYear;
  111.             else {
  112.                 if (ch == 'Y')
  113.             df1 = YearMonDay;
  114.       }
  115.         }
  116.         /* Get 2nd part */
  117.         bQuit = FALSE;
  118.         do{
  119.             lpStr = AnsiNext(lpStr);
  120.             ch = lpStr[0];
  121.             if (ch == chDateMark)
  122.                 bQuit = TRUE;
  123.             if (ch == '\0')
  124.           bQuit = TRUE;
  125.         }while (!bQuit);
  126.         if (ch != '\0') {
  127.             lpStr = AnsiNext(lpStr);
  128.             ch = lpStr[0];
  129.             if (ch == 'M') {
  130.                 df2 = MonDayYear;
  131.             }
  132.             else {
  133.                 if (ch == 'D')
  134.                     df2 = DayMonYear;
  135.                 else
  136.             if (ch == 'Y')
  137.                         df2 = YearMonDay;
  138.             }
  139.       /* Get 3rd part */
  140.             bQuit = FALSE;
  141.             do{
  142.                 lpStr = AnsiNext(lpStr);
  143.                 ch = lpStr[0];
  144.                 if (ch == chDateMark)
  145.                     bQuit = TRUE;
  146.                 if (ch == '\0')
  147.                     bQuit = TRUE;
  148.             }while (!bQuit);
  149.             if (ch != '\0') {
  150.                 lpStr = AnsiNext(lpStr);
  151.                 ch = lpStr[0];
  152.                 if (ch == 'M') {
  153.                     df3 = MonDayYear;
  154.                 }
  155.                 else {
  156.                     if (ch == 'D')
  157.                         df3 = DayMonYear;
  158.                     else
  159.               if (ch == 'Y')
  160.                             df3 = YearMonDay;
  161.                 }
  162.             }
  163.         }
  164.         if ((df1 != NoDateFormat) && (df2 != NoDateFormat) &&
  165.                 (df3 != NoDateFormat)) {
  166.             switch (df1) {
  167.                 case MonDayYear :
  168.                     if (df2 == DayMonYear) {
  169.                         DateFormat = MonDayYear;
  170.                     }
  171.                     else {
  172.                         if (df2 == YearMonDay)
  173.                 DateFormat = MonYearDay;
  174.                     }
  175.           break;
  176.                 case DayMonYear :
  177.                     if (df2 == MonDayYear) {
  178.               DateFormat = DayMonYear;
  179.                     }
  180.                     else {
  181.                         if (df2 == YearMonDay)
  182.                 DateFormat = DayYearMon;
  183.                     }
  184.           break;
  185.                 case YearMonDay :
  186.                     if (df2 == MonDayYear) {
  187.               DateFormat = YearMonDay;
  188.                     }
  189.                     else {
  190.                         if (df2 == DayMonYear)
  191.                 DateFormat = YearDayMon;
  192.                     }
  193.           break;
  194.         default         : break;
  195.       }
  196.     }
  197.     }
  198.   return DateFormat;
  199. }  /* SetDateFormat */
  200.  
  201.  
  202. DATEFORMATTYPE GetDateFormat (void)
  203. {
  204.     /* returns the date format */
  205.     if (DateFormat == NoDateFormat)
  206.       SetDateFormat();
  207.     return DateFormat;
  208. }
  209.  
  210. char *GetDateMark (void)
  211. {
  212.     /* this is the mark that is located  between the
  213.          month, day, and year (i.e. if the date format
  214.          was month/day/year (mm/dd/yy) the DateMark
  215.          would be '/'
  216.   */
  217.     return szDateMark;
  218. }
  219.  
  220. BOOL HasDayZero (void)
  221. {
  222.     /* will day (on short date) that is less
  223.      than 10 include a leading zero */
  224.     return bExtraDayZero;
  225. }
  226.  
  227. BOOL HasMonthZero (void)
  228. {
  229.     /* will month (on short date) that is less
  230.      than 10 include a leading zero */
  231.     return bExtraMonthZero;
  232. }
  233.  
  234. BOOL HasCentury (void)
  235. {
  236.     /* will year (on short date) include the century */
  237.     return bHasCentury;
  238. }
  239.  
  240. void SetInstance(HINSTANCE hInstance)
  241. {
  242.     /* Save the program instance */
  243.     hInst = hInstance;
  244. }
  245.  
  246. HINSTANCE GetInstance(void)
  247. {
  248.     /* return the program instance */
  249.     return hInst;
  250. }
  251.  
  252. void SetWork(WORKTYPE NewWork)
  253. {
  254.     /* Saves the type of work the routines will do */
  255.     Work = NewWork;
  256. }
  257.  
  258. WORKTYPE GetWork(void)
  259. {
  260.     /* Returns the type of work the routines will do */
  261.     return Work;
  262. }
  263.  
  264.  
  265. BOOL GetUsed(void)
  266. {
  267.     return fd.Used;
  268. }
  269.  
  270. void GetName(LPSTR Name)
  271. {
  272.     lstrcat(Name, fd.Name);
  273. }
  274.  
  275. void GetCompany(LPSTR Company)
  276. {
  277.     lstrcat(Company, fd.Company);
  278. }
  279.  
  280. void GetAddress1(LPSTR Address)
  281. {
  282.     lstrcat(Address, fd.Address1);
  283. }
  284.  
  285. void GetAddress2(LPSTR Address)
  286. {
  287.     lstrcat(Address, fd.Address2);
  288. }
  289.  
  290. void GetCity(LPSTR City)
  291. {
  292.     lstrcat(City, fd.City);
  293. }
  294.  
  295. void GetState(LPSTR State)
  296. {
  297.     lstrcat(State, fd.State);
  298. }
  299.  
  300. void GetZip(LPSTR Zip)
  301. {
  302.     lstrcat(Zip, fd.Zip);
  303. }
  304.  
  305. void GetCountry(LPSTR Country)
  306. {
  307.     lstrcat(Country, fd.Country);
  308. }
  309.  
  310. void GetProduct(LPSTR Product)
  311. {
  312.     lstrcat(Product, fd.Product);
  313. }
  314.  
  315. void GetPriceDollar(LPSTR Dollar)
  316. {
  317.     lstrcat(Dollar, fd.PriceDollar);
  318. }
  319.  
  320. void GetPriceCent(LPSTR Cent)
  321. {
  322.     lstrcat(Cent, fd.PriceCent);
  323. }
  324.  
  325. void GetSoldVersion(LPSTR Version)
  326. {
  327.     lstrcat(Version, fd.SoldVersion);
  328. }
  329.  
  330. void GetUpdateVersion(LPSTR Version)
  331. {
  332.     lstrcat(Version, fd.UpdateVersion);
  333. }
  334.  
  335. void GetDay(LPSTR Day)
  336. {
  337.     lstrcat(Day, fd.Day);
  338. }
  339.  
  340. void GetMonth(LPSTR Month)
  341. {
  342.     lstrcat(Month, fd.Month);
  343. }
  344.  
  345. void GetYear(LPSTR Year)
  346. {
  347.     lstrcat(Year, fd.Year);
  348. }
  349.  
  350. void NulData(void)
  351. {
  352.     fd.Name[0]=(char)0;
  353.     fd.Company[0]=(char)0;
  354.     fd.Address1[0]=(char)0;
  355.     fd.Address2[0]=(char)0;
  356.     fd.City[0]=(char)0;
  357.     fd.State[0]=(char)0;
  358.     fd.Zip[0]=(char)0;
  359.     fd.Country[0]=(char)0;
  360.     fd.Invoice[0]=(char)0;
  361.     fd.Product[0]=(char)0;
  362.     fd.PriceDollar[0]=(char)0;
  363.     fd.PriceCent[0]=(char)0;
  364.     fd.SoldVersion[0]=(char)0;
  365.     fd.UpdateVersion[0]=(char)0;
  366.     fd.Day[0] = (char)0;
  367.     fd.Month[0] = (char)0;
  368.     fd.Year[0] = (char)0;
  369.   fd.Used = FALSE;
  370. }
  371.  
  372. void SetUsed(BOOL use)
  373. {
  374.     fd.Used = use;
  375. }
  376.  
  377. void SetName(LPCSTR ne)
  378. {
  379.     lstrcpy(fd.Name, ne);
  380. }
  381.  
  382. void SetCompany(LPCSTR cy)
  383. {
  384.     lstrcpy(fd.Company, cy);
  385. }
  386.  
  387. void SetAddress1(LPCSTR as)
  388. {
  389.     lstrcpy(fd.Address1, as);
  390. }
  391.  
  392. void SetAddress2(LPCSTR as)
  393. {
  394.     lstrcpy(fd.Address2, as);
  395. }
  396.  
  397. void SetCity(LPCSTR cy)
  398. {
  399.     lstrcpy(fd.City, cy);
  400. }
  401.  
  402. void SetState(LPCSTR se)
  403. {
  404.     lstrcpy(fd.State, se);
  405. }
  406.  
  407. void SetZip(LPCSTR zp)
  408. {
  409.     lstrcpy(fd.Zip, zp);
  410. }
  411.  
  412. void SetCountry(LPCSTR cy)
  413. {
  414.     lstrcpy(fd.Country, cy);
  415. }
  416.  
  417. void SetProduct(LPCSTR pt)
  418. {
  419.     lstrcpy(fd.Product, pt);
  420. }
  421.  
  422. void SetDay(LPCSTR dy)
  423. {
  424.     lstrcpy(fd.Day, dy);
  425. }
  426.  
  427. void SetMonth(LPCSTR mh)
  428. {
  429.     lstrcpy(fd.Month, mh);
  430. }
  431.  
  432. void SetYear(LPCSTR yr)
  433. {
  434.     lstrcpy(fd.Year, yr);
  435. }
  436.  
  437. void SetDollar(LPCSTR dr)
  438. {
  439.     lstrcpy(fd.PriceDollar, dr);
  440. }
  441.  
  442. void SetCent(LPCSTR ct)
  443. {
  444.     char ts[6];
  445.     lstrcpy(ts, ct);
  446.     ts[2]=(char)0;
  447.     ls